// $ANTLR 3.2 Sep 23, 2009 12:02:23 X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g 2010-11-01 14:51:27


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;



using Antlr.Runtime.Tree;

public class ExprParser : Parser 
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"NEWLINE", 
		"ID", 
		"INT", 
		"WS", 
		"'='", 
		"'+'", 
		"'-'", 
		"'*'", 
		"'('", 
		"')'"
    };

    public const int WS = 7;
    public const int NEWLINE = 4;
    public const int T__12 = 12;
    public const int T__11 = 11;
    public const int T__13 = 13;
    public const int T__10 = 10;
    public const int INT = 6;
    public const int ID = 5;
    public const int EOF = -1;
    public const int T__9 = 9;
    public const int T__8 = 8;

    // delegates
    // delegators



        public ExprParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public ExprParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
       }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return ExprParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g"; }
    }


    public class prog_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "prog"
    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:9:1: prog : ( stat )+ ;
    public ExprParser.prog_return prog() // throws RecognitionException [1]
    {   
        ExprParser.prog_return retval = new ExprParser.prog_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        ExprParser.stat_return stat1 = null;



        try 
    	{
            // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:9:5: ( ( stat )+ )
            // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:9:9: ( stat )+
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:9:9: ( stat )+
            	int cnt1 = 0;
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( ((LA1_0 >= NEWLINE && LA1_0 <= INT) || LA1_0 == 12) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:9:11: stat
            			    {
            			    	PushFollow(FOLLOW_stat_in_prog36);
            			    	stat1 = stat();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, stat1.Tree);

            			    						if (((stat1 != null) ? ((CommonTree)stat1.Tree) : null) != null){
            			    							Console.WriteLine(((stat1 != null) ? ((CommonTree)stat1.Tree) : null).ToStringTree());
            			    						} else {
            			    							Console.WriteLine();
            			    						}
            			    					

            			    }
            			    break;

            			default:
            			    if ( cnt1 >= 1 ) goto loop1;
            		            EarlyExitException eee1 =
            		                new EarlyExitException(1, input);
            		            throw eee1;
            	    }
            	    cnt1++;
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "prog"

    public class stat_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "stat"
    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:19:1: stat : ( expr NEWLINE -> expr | ID '=' expr NEWLINE -> ^( '=' ID expr ) | NEWLINE ->);
    public ExprParser.stat_return stat() // throws RecognitionException [1]
    {   
        ExprParser.stat_return retval = new ExprParser.stat_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken NEWLINE3 = null;
        IToken ID4 = null;
        IToken char_literal5 = null;
        IToken NEWLINE7 = null;
        IToken NEWLINE8 = null;
        ExprParser.expr_return expr2 = null;

        ExprParser.expr_return expr6 = null;


        CommonTree NEWLINE3_tree=null;
        CommonTree ID4_tree=null;
        CommonTree char_literal5_tree=null;
        CommonTree NEWLINE7_tree=null;
        CommonTree NEWLINE8_tree=null;
        RewriteRuleTokenStream stream_NEWLINE = new RewriteRuleTokenStream(adaptor,"token NEWLINE");
        RewriteRuleTokenStream stream_ID = new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_8 = new RewriteRuleTokenStream(adaptor,"token 8");
        RewriteRuleSubtreeStream stream_expr = new RewriteRuleSubtreeStream(adaptor,"rule expr");
        try 
    	{
            // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:19:5: ( expr NEWLINE -> expr | ID '=' expr NEWLINE -> ^( '=' ID expr ) | NEWLINE ->)
            int alt2 = 3;
            switch ( input.LA(1) ) 
            {
            case INT:
            case 12:
            	{
                alt2 = 1;
                }
                break;
            case ID:
            	{
                int LA2_2 = input.LA(2);

                if ( (LA2_2 == 8) )
                {
                    alt2 = 2;
                }
                else if ( (LA2_2 == NEWLINE || (LA2_2 >= 9 && LA2_2 <= 11)) )
                {
                    alt2 = 1;
                }
                else 
                {
                    NoViableAltException nvae_d2s2 =
                        new NoViableAltException("", 2, 2, input);

                    throw nvae_d2s2;
                }
                }
                break;
            case NEWLINE:
            	{
                alt2 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    throw nvae_d2s0;
            }

            switch (alt2) 
            {
                case 1 :
                    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:19:9: expr NEWLINE
                    {
                    	PushFollow(FOLLOW_expr_in_stat59);
                    	expr2 = expr();
                    	state.followingStackPointer--;

                    	stream_expr.Add(expr2.Tree);
                    	NEWLINE3=(IToken)Match(input,NEWLINE,FOLLOW_NEWLINE_in_stat61);  
                    	stream_NEWLINE.Add(NEWLINE3);



                    	// AST REWRITE
                    	// elements:          expr
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 19:29: -> expr
                    	{
                    	    adaptor.AddChild(root_0, stream_expr.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 2 :
                    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:20:9: ID '=' expr NEWLINE
                    {
                    	ID4=(IToken)Match(input,ID,FOLLOW_ID_in_stat82);  
                    	stream_ID.Add(ID4);

                    	char_literal5=(IToken)Match(input,8,FOLLOW_8_in_stat84);  
                    	stream_8.Add(char_literal5);

                    	PushFollow(FOLLOW_expr_in_stat86);
                    	expr6 = expr();
                    	state.followingStackPointer--;

                    	stream_expr.Add(expr6.Tree);
                    	NEWLINE7=(IToken)Match(input,NEWLINE,FOLLOW_NEWLINE_in_stat88);  
                    	stream_NEWLINE.Add(NEWLINE7);



                    	// AST REWRITE
                    	// elements:          expr, ID, 8
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 20:29: -> ^( '=' ID expr )
                    	{
                    	    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:20:32: ^( '=' ID expr )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_8.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_ID.NextNode());
                    	    adaptor.AddChild(root_1, stream_expr.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;
                case 3 :
                    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:21:9: NEWLINE
                    {
                    	NEWLINE8=(IToken)Match(input,NEWLINE,FOLLOW_NEWLINE_in_stat108);  
                    	stream_NEWLINE.Add(NEWLINE8);



                    	// AST REWRITE
                    	// elements:          
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 21:20: ->
                    	{
                    	    root_0 = null;
                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "stat"

    public class expr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "expr"
    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:24:1: expr : multExpr ( ( '+' | '-' ) multExpr )* ;
    public ExprParser.expr_return expr() // throws RecognitionException [1]
    {   
        ExprParser.expr_return retval = new ExprParser.expr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken char_literal10 = null;
        IToken char_literal11 = null;
        ExprParser.multExpr_return multExpr9 = null;

        ExprParser.multExpr_return multExpr12 = null;


        CommonTree char_literal10_tree=null;
        CommonTree char_literal11_tree=null;

        try 
    	{
            // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:24:5: ( multExpr ( ( '+' | '-' ) multExpr )* )
            // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:24:9: multExpr ( ( '+' | '-' ) multExpr )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_multExpr_in_expr128);
            	multExpr9 = multExpr();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, multExpr9.Tree);
            	// X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:24:18: ( ( '+' | '-' ) multExpr )*
            	do 
            	{
            	    int alt4 = 2;
            	    int LA4_0 = input.LA(1);

            	    if ( ((LA4_0 >= 9 && LA4_0 <= 10)) )
            	    {
            	        alt4 = 1;
            	    }


            	    switch (alt4) 
            		{
            			case 1 :
            			    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:24:19: ( '+' | '-' ) multExpr
            			    {
            			    	// X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:24:19: ( '+' | '-' )
            			    	int alt3 = 2;
            			    	int LA3_0 = input.LA(1);

            			    	if ( (LA3_0 == 9) )
            			    	{
            			    	    alt3 = 1;
            			    	}
            			    	else if ( (LA3_0 == 10) )
            			    	{
            			    	    alt3 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    NoViableAltException nvae_d3s0 =
            			    	        new NoViableAltException("", 3, 0, input);

            			    	    throw nvae_d3s0;
            			    	}
            			    	switch (alt3) 
            			    	{
            			    	    case 1 :
            			    	        // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:24:20: '+'
            			    	        {
            			    	        	char_literal10=(IToken)Match(input,9,FOLLOW_9_in_expr132); 
            			    	        		char_literal10_tree = (CommonTree)adaptor.Create(char_literal10);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal10_tree, root_0);


            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:24:25: '-'
            			    	        {
            			    	        	char_literal11=(IToken)Match(input,10,FOLLOW_10_in_expr135); 
            			    	        		char_literal11_tree = (CommonTree)adaptor.Create(char_literal11);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal11_tree, root_0);


            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_multExpr_in_expr139);
            			    	multExpr12 = multExpr();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, multExpr12.Tree);

            			    }
            			    break;

            			default:
            			    goto loop4;
            	    }
            	} while (true);

            	loop4:
            		;	// Stops C# compiler whining that label 'loop4' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "expr"

    public class multExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "multExpr"
    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:27:1: multExpr : atom ( '*' atom )* ;
    public ExprParser.multExpr_return multExpr() // throws RecognitionException [1]
    {   
        ExprParser.multExpr_return retval = new ExprParser.multExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken char_literal14 = null;
        ExprParser.atom_return atom13 = null;

        ExprParser.atom_return atom15 = null;


        CommonTree char_literal14_tree=null;

        try 
    	{
            // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:28:5: ( atom ( '*' atom )* )
            // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:28:9: atom ( '*' atom )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_atom_in_multExpr161);
            	atom13 = atom();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, atom13.Tree);
            	// X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:28:14: ( '*' atom )*
            	do 
            	{
            	    int alt5 = 2;
            	    int LA5_0 = input.LA(1);

            	    if ( (LA5_0 == 11) )
            	    {
            	        alt5 = 1;
            	    }


            	    switch (alt5) 
            		{
            			case 1 :
            			    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:28:15: '*' atom
            			    {
            			    	char_literal14=(IToken)Match(input,11,FOLLOW_11_in_multExpr164); 
            			    		char_literal14_tree = (CommonTree)adaptor.Create(char_literal14);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal14_tree, root_0);

            			    	PushFollow(FOLLOW_atom_in_multExpr167);
            			    	atom15 = atom();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, atom15.Tree);

            			    }
            			    break;

            			default:
            			    goto loop5;
            	    }
            	} while (true);

            	loop5:
            		;	// Stops C# compiler whining that label 'loop5' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "multExpr"

    public class atom_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "atom"
    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:31:1: atom : ( INT | ID | '(' expr ')' );
    public ExprParser.atom_return atom() // throws RecognitionException [1]
    {   
        ExprParser.atom_return retval = new ExprParser.atom_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken INT16 = null;
        IToken ID17 = null;
        IToken char_literal18 = null;
        IToken char_literal20 = null;
        ExprParser.expr_return expr19 = null;


        CommonTree INT16_tree=null;
        CommonTree ID17_tree=null;
        CommonTree char_literal18_tree=null;
        CommonTree char_literal20_tree=null;

        try 
    	{
            // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:31:5: ( INT | ID | '(' expr ')' )
            int alt6 = 3;
            switch ( input.LA(1) ) 
            {
            case INT:
            	{
                alt6 = 1;
                }
                break;
            case ID:
            	{
                alt6 = 2;
                }
                break;
            case 12:
            	{
                alt6 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d6s0 =
            	        new NoViableAltException("", 6, 0, input);

            	    throw nvae_d6s0;
            }

            switch (alt6) 
            {
                case 1 :
                    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:31:9: INT
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	INT16=(IToken)Match(input,INT,FOLLOW_INT_in_atom184); 
                    		INT16_tree = (CommonTree)adaptor.Create(INT16);
                    		adaptor.AddChild(root_0, INT16_tree);


                    }
                    break;
                case 2 :
                    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:32:9: ID
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	ID17=(IToken)Match(input,ID,FOLLOW_ID_in_atom195); 
                    		ID17_tree = (CommonTree)adaptor.Create(ID17);
                    		adaptor.AddChild(root_0, ID17_tree);


                    }
                    break;
                case 3 :
                    // X:\\Documents\\projects\\WOW developing\\Components\\ANTLR\\ANTLR_tutorial\\Expr.g:33:9: '(' expr ')'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal18=(IToken)Match(input,12,FOLLOW_12_in_atom205); 
                    	PushFollow(FOLLOW_expr_in_atom208);
                    	expr19 = expr();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, expr19.Tree);
                    	char_literal20=(IToken)Match(input,13,FOLLOW_13_in_atom210); 

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "atom"

    // Delegated rules


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_stat_in_prog36 = new BitSet(new ulong[]{0x0000000000001072UL});
    public static readonly BitSet FOLLOW_expr_in_stat59 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_NEWLINE_in_stat61 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_stat82 = new BitSet(new ulong[]{0x0000000000000100UL});
    public static readonly BitSet FOLLOW_8_in_stat84 = new BitSet(new ulong[]{0x0000000000001060UL});
    public static readonly BitSet FOLLOW_expr_in_stat86 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_NEWLINE_in_stat88 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NEWLINE_in_stat108 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_multExpr_in_expr128 = new BitSet(new ulong[]{0x0000000000000602UL});
    public static readonly BitSet FOLLOW_9_in_expr132 = new BitSet(new ulong[]{0x0000000000001060UL});
    public static readonly BitSet FOLLOW_10_in_expr135 = new BitSet(new ulong[]{0x0000000000001060UL});
    public static readonly BitSet FOLLOW_multExpr_in_expr139 = new BitSet(new ulong[]{0x0000000000000602UL});
    public static readonly BitSet FOLLOW_atom_in_multExpr161 = new BitSet(new ulong[]{0x0000000000000802UL});
    public static readonly BitSet FOLLOW_11_in_multExpr164 = new BitSet(new ulong[]{0x0000000000001060UL});
    public static readonly BitSet FOLLOW_atom_in_multExpr167 = new BitSet(new ulong[]{0x0000000000000802UL});
    public static readonly BitSet FOLLOW_INT_in_atom184 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_atom195 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_12_in_atom205 = new BitSet(new ulong[]{0x0000000000001060UL});
    public static readonly BitSet FOLLOW_expr_in_atom208 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_13_in_atom210 = new BitSet(new ulong[]{0x0000000000000002UL});

}
